home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / CIncludes / DeskBus.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-01  |  8.5 KB  |  236 lines  |  [TEXT/MPS ]
  1. /*
  2.      File:        DeskBus.h
  3.  
  4.      Contains:    Apple Desktop Bus (ADB) Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. */
  18. #ifndef __DESKBUS__
  19. #define __DESKBUS__
  20.  
  21. #ifndef __TYPES__
  22. #include <Types.h>
  23. #endif
  24. #ifndef __MIXEDMODE__
  25. #include <MixedMode.h>
  26. #endif
  27.  
  28. #ifdef __cplusplus
  29. extern "C" {
  30. #endif
  31.  
  32. #if PRAGMA_IMPORT_SUPPORTED
  33. #pragma import on
  34. #endif
  35.  
  36. #if PRAGMA_ALIGN_SUPPORTED
  37. #pragma options align=mac68k
  38. #endif
  39.  
  40. #if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE
  41. typedef SInt8 ADBAddress;
  42. /*
  43.         This ProcPtr uses register based parameters on the 68k and cannot
  44.         be written in or called from a high-level language without the help of
  45.         mixed mode or assembly glue.
  46.  
  47.             typedef pascal void (*ADBCompletionProcPtr)(Ptr buffer, Ptr refCon, long command);
  48.  
  49. */
  50. /*
  51.         This ProcPtr uses register based parameters on the 68k and cannot
  52.         be written in or called from a high-level language without the help of
  53.         mixed mode or assembly glue.
  54.  
  55.             typedef pascal void (*ADBDeviceDriverProcPtr)(SInt8 devAddress, SInt8 devType);
  56.  
  57. */
  58. /*
  59.         This ProcPtr uses register based parameters on the 68k and cannot
  60.         be written in or called from a high-level language without the help of
  61.         mixed mode or assembly glue.
  62.  
  63.             typedef pascal void (*ADBServiceRoutineProcPtr)(Ptr buffer, ADBServiceRoutineUPP completionProc, Ptr refCon, long command);
  64.  
  65. */
  66. /*
  67.         This ProcPtr uses register based parameters on the 68k and cannot
  68.         be written in or called from a high-level language without the help of
  69.         mixed mode or assembly glue.
  70.  
  71.             typedef pascal void (*ADBInitProcPtr)(SInt8 callOrder);
  72.  
  73. */
  74.  
  75. #if GENERATINGCFM
  76. typedef UniversalProcPtr ADBCompletionUPP;
  77. typedef UniversalProcPtr ADBDeviceDriverUPP;
  78. typedef UniversalProcPtr ADBServiceRoutineUPP;
  79. typedef UniversalProcPtr ADBInitUPP;
  80. #else
  81. typedef Register68kProcPtr ADBCompletionUPP;
  82. typedef Register68kProcPtr ADBDeviceDriverUPP;
  83. typedef Register68kProcPtr ADBServiceRoutineUPP;
  84. typedef Register68kProcPtr ADBInitUPP;
  85. #endif
  86. struct ADBDataBlock {
  87.     SInt8                             devType;                    /* original handler ID */
  88.     SInt8                             origADBAddr;                /* original ADB Address */
  89.     ADBServiceRoutineUPP             dbServiceRtPtr;                /* service routine pointer */
  90.     Ptr                             dbDataAreaAddr;                /* this field is passed as the refCon parameter to the service routine */
  91. };
  92. typedef struct ADBDataBlock ADBDataBlock;
  93.  
  94. typedef ADBDataBlock *ADBDBlkPtr;
  95. struct ADBSetInfoBlock {
  96.     ADBServiceRoutineUPP             siService;                    /* service routine pointer */
  97.     Ptr                             siDataAreaAddr;                /* this field is passed as the refCon parameter to the service routine */
  98. };
  99. typedef struct ADBSetInfoBlock ADBSetInfoBlock;
  100.  
  101. typedef ADBSetInfoBlock *ADBSInfoPtr;
  102. /* ADBOpBlock is only used when calling ADBOp from 68k assembly code */
  103. struct ADBOpBlock {
  104.     Ptr                             dataBuffPtr;                /* buffer: pointer to variable length data buffer */
  105.     ADBServiceRoutineUPP             opServiceRtPtr;                /* completionProc: completion routine pointer */
  106.     Ptr                             opDataAreaPtr;                /* refCon: this field is passed as the refCon parameter to the completion routine */
  107. };
  108. typedef struct ADBOpBlock ADBOpBlock;
  109.  
  110. typedef ADBOpBlock *ADBOpBPtr;
  111. extern pascal void ADBReInit(void )
  112.  ONEWORDINLINE(0xA07B);
  113.  
  114. /*
  115.     ADBOp has a different interface for 68k assembly than for everything else
  116.     for 68k assembly the interface is 
  117.     #pragma parameter __D0 ADBOp(__A0,__D0)
  118.     OSErr ADBOp( ADBOpBlock * pb, short commandNum );
  119. */
  120. /*
  121.     IMPORTANT NOTE:
  122.     "Inside Macintosh: Devices" documents the completion routine for ADBOp will be called with
  123.     four parameters using 68k register based calling conventions, specifically the completion routine
  124.     passed in should be of type ADBServiceRoutineProcPtr. However, when upp types were first added
  125.     to this interface file, the type ADBCompletionUPP was mistakenly used for the second parameter
  126.     to ADBOp. Since applications have shipped using completion routines of type ADBCompletionUPP,
  127.     the mistake cannot be corrected.
  128.     The only difference between ADBServiceRoutineUPP and ADBCompletionUPP is the former takes an extra
  129.     argument which is a pointer to itself, fortunately not needed for PowerPC code.
  130.     For compatibility with existing 68k code, when an ADBOp completion routine is called,
  131.     68k register A1 will point to the completion routine, as documented in Inside Mac.
  132. */
  133. extern pascal OSErr ADBOp(Ptr refCon, ADBCompletionUPP compRout, Ptr buffer, short commandNum);
  134.  
  135.  
  136. #if GENERATING68K && !GENERATINGCFM
  137. #pragma parameter __D0 CountADBs
  138. #endif
  139. extern pascal short CountADBs(void )
  140.  ONEWORDINLINE(0xA077);
  141.  
  142.  
  143. #if GENERATING68K && !GENERATINGCFM
  144. #pragma parameter __D0 GetIndADB(__A0, __D0)
  145. #endif
  146. extern pascal ADBAddress GetIndADB(ADBDataBlock *info, short devTableIndex)
  147.  ONEWORDINLINE(0xA078);
  148.  
  149.  
  150. #if GENERATING68K && !GENERATINGCFM
  151. #pragma parameter __D0 GetADBInfo(__A0, __D0)
  152. #endif
  153. extern pascal OSErr GetADBInfo(ADBDataBlock *info, ADBAddress adbAddr)
  154.  ONEWORDINLINE(0xA079);
  155.  
  156.  
  157. #if GENERATING68K && !GENERATINGCFM
  158. #pragma parameter __D0 SetADBInfo(__A0, __D0)
  159. #endif
  160. extern pascal OSErr SetADBInfo(const ADBSetInfoBlock *info, ADBAddress adbAddr)
  161.  ONEWORDINLINE(0xA07A);
  162.  
  163.  
  164. #if GENERATINGCFM
  165. #else
  166. #endif
  167.  
  168. enum {
  169.     uppADBCompletionProcInfo = kRegisterBased
  170.          | REGISTER_ROUTINE_PARAMETER(1, kRegisterA0, SIZE_CODE(sizeof(Ptr)))
  171.          | REGISTER_ROUTINE_PARAMETER(2, kRegisterA2, SIZE_CODE(sizeof(Ptr)))
  172.          | REGISTER_ROUTINE_PARAMETER(3, kRegisterD0, SIZE_CODE(sizeof(long))),
  173.     uppADBDeviceDriverProcInfo = kRegisterBased
  174.          | REGISTER_ROUTINE_PARAMETER(1, kRegisterD0, SIZE_CODE(sizeof(SInt8)))
  175.          | REGISTER_ROUTINE_PARAMETER(2, kRegisterD1, SIZE_CODE(sizeof(SInt8))),
  176.     uppADBServiceRoutineProcInfo = kRegisterBased
  177.          | REGISTER_ROUTINE_PARAMETER(1, kRegisterA0, SIZE_CODE(sizeof(Ptr)))
  178.          | REGISTER_ROUTINE_PARAMETER(2, kRegisterA1, SIZE_CODE(sizeof(ADBServiceRoutineUPP)))
  179.          | REGISTER_ROUTINE_PARAMETER(3, kRegisterA2, SIZE_CODE(sizeof(Ptr)))
  180.          | REGISTER_ROUTINE_PARAMETER(4, kRegisterD0, SIZE_CODE(sizeof(long))),
  181.     uppADBInitProcInfo = kRegisterBased
  182.          | REGISTER_ROUTINE_PARAMETER(1, kRegisterD0, SIZE_CODE(sizeof(SInt8)))
  183. };
  184.  
  185. #if GENERATINGCFM
  186. #define NewADBCompletionProc(userRoutine)        \
  187.         (ADBCompletionUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppADBCompletionProcInfo, GetCurrentArchitecture())
  188. #define NewADBDeviceDriverProc(userRoutine)        \
  189.         (ADBDeviceDriverUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppADBDeviceDriverProcInfo, GetCurrentArchitecture())
  190. #define NewADBServiceRoutineProc(userRoutine)        \
  191.         (ADBServiceRoutineUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppADBServiceRoutineProcInfo, GetCurrentArchitecture())
  192. #define NewADBInitProc(userRoutine)        \
  193.         (ADBInitUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppADBInitProcInfo, GetCurrentArchitecture())
  194. #else
  195. #define NewADBCompletionProc(userRoutine)        \
  196.         ((ADBCompletionUPP) (userRoutine))
  197. #define NewADBDeviceDriverProc(userRoutine)        \
  198.         ((ADBDeviceDriverUPP) (userRoutine))
  199. #define NewADBServiceRoutineProc(userRoutine)        \
  200.         ((ADBServiceRoutineUPP) (userRoutine))
  201. #define NewADBInitProc(userRoutine)        \
  202.         ((ADBInitUPP) (userRoutine))
  203. #endif
  204.  
  205. #if GENERATINGCFM
  206. #define CallADBCompletionProc(userRoutine, buffer, refCon, command)        \
  207.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppADBCompletionProcInfo, (buffer), (refCon), (command))
  208. #define CallADBDeviceDriverProc(userRoutine, devAddress, devType)        \
  209.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppADBDeviceDriverProcInfo, (devAddress), (devType))
  210. #define CallADBServiceRoutineProc(userRoutine, buffer, completionProc, refCon, command)        \
  211.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppADBServiceRoutineProcInfo, (buffer), (completionProc), (refCon), (command))
  212. #define CallADBInitProc(userRoutine, callOrder)        \
  213.         CallUniversalProc((UniversalProcPtr)(userRoutine), uppADBInitProcInfo, (callOrder))
  214. #else
  215. /* (*ADBCompletionUPP) cannot be called from a high-level language without the Mixed Mode Manager */
  216. /* (*ADBDeviceDriverUPP) cannot be called from a high-level language without the Mixed Mode Manager */
  217. /* (*ADBServiceRoutineUPP) cannot be called from a high-level language without the Mixed Mode Manager */
  218. /* (*ADBInitUPP) cannot be called from a high-level language without the Mixed Mode Manager */
  219. #endif
  220. #endif
  221.  
  222. #if PRAGMA_ALIGN_SUPPORTED
  223. #pragma options align=reset
  224. #endif
  225.  
  226. #if PRAGMA_IMPORT_SUPPORTED
  227. #pragma import off
  228. #endif
  229.  
  230. #ifdef __cplusplus
  231. }
  232. #endif
  233.  
  234. #endif /* __DESKBUS__ */
  235.  
  236.